MUM 2023 modele konwolucyjne¶
import math
import torch
from torch import nn
from d2l import torch as d2l
import matplotlib
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
- modele typu MLPokazują się bardzo nieefektywne przy danych tablicowych
- obraz 1000 na 1000 z 1000 na 1000 neuronów w warstwie ukrytej będzie już od razu miał $10^{12}$ parametrów
- architektura kompletnie nie wykorzystuje redundancji obrazów (danych)
- inwariancja ze względu na translację, obrót
- MLP nie wykorzystuje lokalności danych
konwolucje¶
- niech sieć (MLP) "każdy z każdym" ma 2-wymiarowe wejściowe obrazy $X$ (indeksowane przez k, l) oraz ukryte reprezentacje $H$ (indeksowane i, j)
$$\begin{align}
[H]_{ij}&=[U]_{ij}+\sum_k\sum_l[W]_{ijkl}[X]_{kl}\\
&=[U]_{ij}+\sum_a\sum_b[V]_{ijab}[X]_{i+a,j+b}
\end{align}$$
- zamiana W na V to tylko przeindeksowanie $[W]_{ijkl}=[V]_{i, j, i+a, j+b}$
- W jest 4-wymiarowym tensorem
- niezależność ze względu na translację: niech macierz $[V]$ będzie niezależna od położenia i przesunięcie wejścia powoduje przesunięcie wartości ukrytej
$$[H]_{ij}=u+\sum_a\sum_b[V]_{ab}[X]_{i+a,j+b}$$
wartość $u$ jest wobec tego skalarem niezależnym od położenia
w ten sposób mamy konwolucję $$(f\ast{}g)(x)=\int{}f(z)g(x-z)dz$$
- dla obrazów w postaci dyskretnej mamy $$(f\ast{}g)(i)=\sum_a f(a)g(i-a)$$ lub dla dwuwymiarowych $$(f\ast{}g)(i,j)=\sum_a\sum_b f(a,b)g(i-a,j-b)$$
dla $a,b\in(-1000, 1000)$ dostajemy $4\times10^6$ parametrów
tak zdefiniowane konwolucje powinny być zwane kross-korelacjami
lokalność¶
- kolejnym założeniem jest, że wartość $[H]_{ij}$ powinna być zależna jedynie od niewielu punktów w otoczeniu $[X]_{ij}$
$$[H]_{ij}=u+\sum_{-\Delta}^{+\Delta}\sum_{-\Delta}^{+\Delta}[V]_{ab}[X]_{i+a,j+b}$$
- to ogranicza liczbę parametrów do $4\times\Delta^2$
- $\Delta$ jest tu użyta jako promień
- $[V]$ nazywamy zwykle kernelem
- mamy bardzo ograniczoną liczbę parametrów
- parametry są dzielone (shared), a więc uczą się wykrywania tych samych cech w różnych częściach wejścia
- to ogranicza liczbę parametrów do $4\times\Delta^2$
kanały¶
w przypadku obrazów każdy piksel jest zwykle złożony z trzech kolorów -- kanałów
- macierz parametrów staje się trójwymiarowa $[V]_{a,b,c}$
- dla każdego położenia będziemy mieli cały wektor reprezentacji o indeksowany przez $d$, tworzący nowy kanał w reprezentacji ukrytej $$[H]_{ijd}=\sum_{-\Delta}^{+\Delta}\sum_{-\Delta}^{+\Delta}\sum_c[V]_{abcd}[X]_{i+a,j+b,c}$$ dając trzeci wymiar $H$
- oczywiście nie tylko kolory są legalnymi kanałami
- rzeczywiste obrazy są tworzone w bardzo wielu kanałach odpowiadających różnym częstotliwościom
- w szczególności utworzone powyżej reprezentacje też generują kanały
konwolucje przez dzielenie wag ograniczają liczbę parametrów
w dalszym ciągu bardzo wysoka jest liczba koniecznych obliczeń rzędu $O(h\cdot w\cdot k^2\cdot{}c_{in}\cdot{}c_{out})$ dla konwolucji $k\times{}k$
padding, stride, dilation¶
- obliczając cross-correlation obrazu z kernelem konwolucji, zwykle
- zaczynamy od lewego górnego, kończymy na prawym dolnym rogu,
- przesunięcie o jeden w poziomie i pionie
co powoduje zredukowanie informacji o brzegach oraz zmniejszenie obrazu
padding¶
- dodanie kolumn i wierszy po wszystkich stronach
- dodaje kontrolę nad wymiarem
- zachowanie informacji o brzegach
- zwykle zera na dodanych pozycjach - algorytm może wiedzieć gdzie "zaczynają" się zera bez ich fizycznej reprezentacji
- padding nie musi być wypełniony zerami, ale nie ma jasnych wskazówek kiedy
- zapewnia, że wszystkie piksele są używane równie często
stride¶
- przeskok obliczeń co ustaloną liczbę wierszy / kolumn
- zwykle, podobnie jak padding, takie same w poziomie i pionie
- forma downsamplingu dla efektywności
- szczególnie gdy same konwolucje są duże
dilation¶
- dodanie przerw co ustaloną liczbę kolumn/wierszy
- dylacja k oznacza opuszczenie k-1 wierszy / kolumn
- zwykle przy pozostawionym stride, niekoniecznie
- dylacja zwiększa kwadratowo (wykładniczo dla większej liczby wymiarów wejsciowego "obrazu") pola recepcyjnego
- większe zwrócenie uwagi na ogólne cechy
- ewentualnie także przyspieszenie pracy
Wiele kanałów¶
wiele kanałów wejściowych¶
- dla RGB konwolucje są w rzeczywistości $w\times h\times3$ dla $c_{in}=3$ (załóżmy obraz 2-wymiarowy))
- dla każdego kanału jest osobna konwolucja $w\times h$
- obliczane niezależnie na każdym kanale
- na końcu sumowane w poprzek kanałów
- o ile jest jeden kanał wyjściowy
i wiele wyjściowych¶
- większość modeli CNN zmniejsza wymiarowość przestrzenną, jednocześnie zwiększając liczbę kanałów (głębokość)
- kanały są wykorzystywane wspólnie
- dla każdego z wielu kanałów wyjściowych tworzona jest konwolucja $c_{in}\times w\times h$
- poszczególne wyniki są konkatenowane
- w efekcie kernel jest $c_{in}\times{}c_{out}\times{}w\times{}h$
- prosta intuicja mówiłaby, ze kanały wydobywają różne cechy
- w rzeczywistości poszczególne kanały wykrywają wiele cech jednocześnie
- dla każdego z wielu kanałów wyjściowych tworzona jest konwolucja $c_{in}\times w\times h$
konwolucje $1\times1$¶
- najprościej patrząc konwolucja $1\times1$ oblicza korelację sąsiadujących w kanałach wektorów pikseli
- nie wykorzystuje informacji o sąsiedztwie
- wciąż może być wiele kanałów wyjściowych
- zwykle po takich konwolucjach użyta jest funkcja nieliniowa
- podobieństwo do obliczeń w MLP
pooling¶
- model CNN agreguje informacje z cech niższego poziomu na bardziej ogólne
- prostym przykładem jest składanie liter z linii, bądźmy ostrożni z tak symplicystycznym wytłumaczeniem
- potrzebny jest operator pozwalający na niezależność cech od przesunięcia
max-pooling¶
- w neuronaukach informacja jest agregowana w sposób hierarchiczny
- max-pooling odpowiada wyborowi najsilniejszej cechy i jest zwykle efektywniejsza od average-pooling
- jeśli kernel konwolucji ma wykrywać krawędzie, to max-pooling odpowie czy krawędź jest obecna na którymkolwiek z pól szerszego obszaru
- obliczenia są proste z użyciem operatora max lub średniej
- pooling zmniejsza obszar
- możemy uzyć odpowiednich padding czy stride dla utrzymania odpowiednich wymiarów
- pooling nie zmienia liczby kanałów
- operator pooling jest aplikowany do każdego kanału osobno
average-pooling¶
- przypomina / jest równoważne zmniejszanie rozdzielczości obrazu
- zamiast szukania cech pomijając kolumny/wiersze, lepiej jest uśrednić znalezione cechy
Uczenie¶
- wszystkie parametry konwolucji są wyszukiwane w trakcie uczenia
- zwykle standardowe uczenie wsteczną propagacją
- hiper-parametry padding, stride, dilation, pooling są ustalone
- istnieją odmiany pooling, które są uczone, chociaż w metodach attention
- potrzeba dobrze zaprojektować model CNN
- w sieci jest wiele kalkulatorów dla obliczania wielkości kolejnych warstw (nie, żeby to było trudne) 😩 $$out=\left\lfloor\dfrac{in + 2 * padding - (kernel - 1) - 1}{stride}\right\rfloor+1$$
LeNet¶
projekt Yanna LeCunn (wtedy Bell Labs, obecnie profesor na NYU, szef naukowy na Meta (nie jestem pewien czy wciąż) jeden z guru AI i sieci neuronowych w szczególności) i Leona Bottou, lata 1990...
oryginalnie dla obrazów MNIST, $28\times28$, razem 784 pikseli
- oryginalne obrazy miały wymiar 32 na 32, ale zostały obcięte dla oszczędności
- LeNet został zastosowany do maszyn ATM - niektóre wciąż używają
- poniżej 1% błędu
bloki konwolucyjne Cn z sigmoidalną aktywacją
- C1 ma 6 kanałów wyjściowych, C3 ma 16
- konwolucje 5 na 5
- pierwsza warstwa ma w rzeczywistości padding=2, odpowiadający usuniętym pikselom
- druga warstwa konwolucyjna nie dodaje padding
bloki average-pooling S
- każdy pooling o wymiarach 2 na 2, ze stride=2
na końcu warstwy liniowe z sigmoidalną aktywacją o wielkościach 120, 84, i 10 (tyle ile cyfr)
- oryginalnie gausowska funkcja aktywacji
model osiąga błąd na zbiorach uczących, walidacyjnych i testowych poniżej 1% już po kilkunastu epokach
AlexNet [Krizhevsky, Sutskever, Hinton, ImageNet Classification with deep convolutional neural networks]¶
- przez długi czas sieci neuronowe nie były w stanie przetwarzać dużych zbiorów i uczyć się niskopoziomowych cech
- zwykle cechy były tworzone "ręcznie" by używać linowych klasyfikatorów
- dopiero AlexNet [Krizhevsky et al., 2012] był pierwszym modelem, w którym powstało uczenie reprezentacji (representation learning)
- zamiast projektować cechy, model uczył się istotnych dla problemu filtrów
- okazało się, że dla zadań rozpoznawania obrazów są one bardzo zbieżne z filtrami Gabora
- również znalezionymi w układzie wzrokowym
[Krizhevsky et al]
- dane ImageNet 2009: milion obrazów - 1000 obrazów z każdej z 1000 klas zorganizowanych hierarchicznie WordNet
- obrazy 224 na 224
- konkurs ILSVRC
- szczęśliwie pojawiły się rozwiązania GPU dla gier komputerowych, później uogólnione
- GPU są zwykle znacznie bardziej efektywne energetycznie
- wykonują bardzo wiele prostych operacji równolegle
- to jest spójne z koncepcją grafu obliczeń
Architektura AlexNet¶
- koncepcją było wykorzystanie GPU i zoptymalizowanie architektury dla dwóch jednostek
- konwolucje 11 na 11 w pierwszej warstwie
- w następnej konwolucje 5 na 5, a potem 3 na 3
- wykorzystuje max-pooling
- znacznie więcej kanałów niż LeNet (obrazy są zresztą kolorowe)
- na końcu dwie warstwy FF z 4096 neuronami każda co wymaga około 1GB parametrów
- ze względu na ograniczone zasoby użytych GPU, model został oryginalnie podzielony na dwie części
- każdy procesor obsługiwał jedynie połowę parametrów
- AlexNet wykorzystał aktywację ReLU
- znacznie prostsze obliczenia
- zapobiega przed problemem zanikającego gradientu przy wysyconych wartościach sum
- uczenie
- LeNet wykorzystywał jedynie weight decay
- w AlexNet autorzy dodali bardzo wiele augmentacji danych
- odwracanie, translacja, i obcinanie obrazu
- modyfikacje kolorów
- znacznie większy zbiór danych zabezpieczał przed overfittingiem
- AlexNet wygrywając ILSVRC-2012 z dużą przewagą okazał się przełomowym rozwiązaniem przekraczając Rubikon od sieci płytkich do głębokich
- z jednej strony poprawienie LeNet
- skok dzięki ReLU
- ostatnie dwie warstwy miały $6400\times4096+4096\times4096$ parametrów!
- wciąż jednak długo nie było powszechnie dostępnych narzędzi programistycznych
VGG net (Visual Geometry Group, Oxford) [Karen Simonyan, Andrew Zisserman 2014]¶
podczas gdy AlexNet był architekturą zaprojektowaną od początku do końca, VGG był propozycją modułową z powtarzalnych bloków
- warstwy konwolucyjnej z paddingiem dla utrzymania rozdzielczości
- nieliniowości typu ReLU
- pooling typu max-pooling dla redukcji rozdzielczości
- w CNN rozdzielczość spada szybko dając ścisłe ograniczenie na liczbę warstw rzędu $\log_2 d$ gdzie $d$ jest wymiarem wejścia (dla ImageNet to daje 8 warstw konwolucyjnych)
w VGG autorzy zaproponowali głębsze modele raczej niż szersze przez wiele kolejnych mniejszych konwolucji
- przykładowo trzy warstwy konwolucji $3\times3$
- dodanie paddingu 1 w każdym kierunku nie zmniejsza wymiaru
- to daje $3\cdot9\cdot{}c^2$ parametrów
- podczas gdy konwolucja $5\times5$ (jak w AlexNet)
- dla nie zmniejszania wymiaru konieczny padding 2
- parametrów $25\times{}c^2$, a więc bardzo podobna liczba
- konwolucję $7\times7$ mamy $7\times7$ można zastąpić pięcioma konwolucjami $3\times3$ o liczbie $5\times3\times3$ parametrów *też padding 1 by nie zmniejszać wymiarów
- w każdym bloku VGG dwie warstwy konwolucyjne
- zwykle znacznie zwiększają liczbę kanałów
- a następnie warstwa max-pool redukująca wymiar
- blokowa konstrukcja pozwala na budowę modelu o (prawie) dowolnej głębokości
- przykładowo trzy warstwy konwolucji $3\times3$
VGG-16 ma trochę ponad 138 milionów parametrów, AlexNet ponad 62 miliony
| warstwa | in | out | layer | stride | kernel | param | | ---: | :--- | :--- | :--- | ---: | :--- | ---: | | 1 | 224 x 224 x 3 | 224 x 224 x 64 | conv | 1 | 3 x 3 | 1,792 | | 2 | 224 x 224 x 64 | 224 x 224 x 64 | conv | 1 | 3 x 3 | 36,928 | | | 224 x 224 x 64 | 112 x 112 x 64 | max-pool | 2 | 2 x 2 | | | 3 | 112 x 112 x 64 | 112 x 112 x 128 | conv | 1 | 3 x 3 | 73,856 | | 4 | 112 x 112 x 128 | 112 x 112 x 128 | conv | 1 | 3 x 3 | 147,584 | | | 112 x 112 x 128 | 56 x 56 x 128 | max-pool | 2 | 2 x 2 | | | 5 | 56 x 56 x 128 | 56 x 56 x 256 | conv | 1 | 3 x 3 | 295,168 | | 6 | 56 x 56 x 256 | 56 x 56 x 256 | conv | 1 | 3 x 3 | 590,080 | | 7 | 56 x 56 x 256 | 56 x 56 x 256 | conv | 1 | 3 x 3 | 590,080 | | | 56 x 56 x 256 | 28 x 28 x 256 | max-pool | 2 | 2 x 2 | | | 8 | 28 x 28 x 256 | 28 x 28 x 512 | conv | 1 | 3 x 3 | 1,180,160 | | 9 | 28 x 28 x 512 | 28 x 28 x 512 | conv | 1 | 3 x 3 | 2,359,808 | | 10 | 28 x 28 x 512 | 28 x 28 x 512 | conv | 1 | 3 x 3 | 2,359,808 | | | 28 x 28 x 512 | 14 x 14 x 512 | max-pool | 2 | 2 x 2 | | | 11 | 14 x 14 x 512 | 14 x 14 x 512 | conv | 1 | 3 x 3 | 2,359,808 | | 12 | 14 x 14 x 512 | 14 x 14 x 512 | conv | 1 | 3 x 3 | 2,359,808 | | 13 | 14 x 14 x 512 | 14 x 14 x 512 | conv | 1 | 3 x 3 | 2,359,808 | | | 14 x 14 x 512 | 7 x 7 x 512 | max-pool | 2 | 2 x 2 | | | 14 | 1 x 1 x 25088 | 1 x 1 x 4096 | feed-forward | | 1 x 1 | 102,764,544 | | 15 | 1 x 1 x 4096 | 1 x 1 x 4096 | feed-forward | | 1 x 1 | 16,781,312 | | 16 | 1 x 1 x 4096 | 1 x 1 x 1000 | feed-forward | | 1 x 1 | 4,097,000 | | | | | | | razem | 138,423,208 |
jest wiele predefiniowanych architektur VGGNet umożliwiających pewne zrównoważenie między jakością a złożonością
możliwe, że sieci płytsze, ale szersze pozwalają na podobną jakość przy szybszym uczeniu
VGGNet wciąż ma warstwy feed-forward na końcu, które mają olbrzymią liczbę parametrów
Czy możliwa jest optymalizacja tych architektur?¶
- wszystkie mają warstwy feed-forward z olbrzymią liczbą parametrów
- taka warstwa jest olbrzymią macierzą trudną do przetwarzania na mniejszych urządzeniach
- propozycja uproszczenia
- użycie konwolucji $1\times1$ dla dodania lokalnych nieliniowości
- dodanie average-pooling na samym końcu
- architektura network-in-network [Lin, Chen, Yan, Network in network, 2013] wykorzystuje blok zastępujący blok w VGG
- konwolucja $n\times{}n$
- konwolucja $1\times1$
- konwolucja $1\times1$
- w kolejnych blokach NiN konwolucje
- $11\times11$ ze stride 4, 96 kanałów
- $5\times5$ z paddingiem 2, 256 kanałów
- $3\times3$ z paddingiem 1, 384 kanały
- $3\times3$ z paddingiem 1, 10 kanałami (tyle ile klas wyjściowych)
- bez warstw feed-forward na końcu
- na końcu każdy kanał jest uśredniony przez average pooling
- aby ta operacja miała sens, konieczne są konwolucje $1\times1$
- konwolucje $1\times1$
- operują na pojedynczych pikselach
- można traktować jako wielowymiarowe warstwy feed-forward uczone na pojedynczych pikselach obrazu
- ta budowa znacznie zmniejsza liczbę uczonych parametrów
- ten model trochę idzie w szerokość poprzez konwolucje na początku
- jednocześnie w głębokość przez konwolucje $1\times1$
Wszystko razem: różne wymiary konwolucji, konwolucje $1\times1$, bloki, ale też rozwarstwienia [Szegedy, Going deeper with convolutions, 2014]¶
konwolucje przetwarzają obraz na różnych poziomach łącząc wyniki
- zwykle badacze szukają optymalnej konwolucji dla problemu, albo ustalają stałą, np. VGG
- każdy problem ma inne wymagania
- rozpoznawanie jest zależne od tego, jaką frakcję całego wejścia (obrazu) zajmuje istotna informacja
- zbyt głębokie sieci mają skłonność do zbytniego dopasowania (overfitting)
- zwykle badacze szukają optymalnej konwolucji dla problemu, albo ustalają stałą, np. VGG
konwolucje $1\times1$ pozwalają na zwiększenie wymiarowości dodając nieliniowości stosunkowo niskim kosztem
- GoogLeNet po prostu konkatenuje wyniki!
- oryginalne rozwiązanie dodawało dodatkowe funkcje pośrednie dla zwiększenia stabilności uczenia w złożonej architekturze
- nowe algorytmy uczące, wraz z normalizacją (BatchNorm) pozwoliły na uniknięcie
- konwolucje używają odpowiednich paddingów dla utrzymania wymiarów by móc konkatenować wyniki
Inception v1¶
- model jest głęboki (22 poziomy konwolucji) powodując zanikanie gradientów w środkowej części
- dodatkowe dwa poziomy klasyfikacyjne - softmax do pośrednich wyników - w środkowej części
- całkowita wartość loss jako suma ważona (zwykle z wagą $\sim0.3$ dla każdego wyjścia)
Inception v2¶
- konwolucje o większych wymiarach za szybko zmniejszają wymiar, powodując wąskie gardło informacyjne (ang. information bottleneck), jednocześnie spowalniając
- faktoryzacja konwolucji $5\times5$ na dwie konwolucje $3\times3$
- efektywniejsze — prawie 3 razy szybsze obliczenia
- zamiana konwolucji $n\times{}n$ na sekwencję konwolucji $n\times1$ oraz $1\times{}n$, co dla konwolucji $3\times3$ okazuje się o jedną trzecią szybsze!
- także banki filtrów: zamiast sekwencji $3\times1$ oraz $1\times3$ zrobić równolegle $n\times1$ oraz $1\times{}n$ a następnie konkatenować wyniki
- faktoryzacja konwolucji $5\times5$ na dwie konwolucje $3\times3$
Inception v3¶
- dodatkowe klasyfikatory pośrodku pnia Inception w niewiele dają
- uczenie poprawia się dopiero gdy osiągana klasyfikacja jest prawie pewna (saturacja)
- konieczna regularyzacja pośrednich klasyfikatorów
- modyfikacja Inception v2 przez
- zmianę uczenia na RMSProp
- faktoryzację konwolucji $7\times7$
- dodanie BatchNorm w pośrednich klasyfikatorach
- regularyzacja przez wygładzanie etykiet [Muller, Kornblith, Hinton, When does label smoothing help?, 2019]
- jeśli etykiety są nieprawidłowe, to maksymalizacja $p(y\mid x)$ może być szkodliwa
- założenie, że dostępna etykieta jest prawdziwa z prawdopodobieństwem $1-\epsilon$
- zamiana etykiet $0, 1$ na $\dfrac{\epsilon}{k-1}, 1-\epsilon$ dla wektora wyjściowego one-hot o $k$ składnikach
- po modyfikacji wciąż sumuje się do 1
- uczenie poprawia się dopiero gdy osiągana klasyfikacja jest prawie pewna (saturacja)
Inception v4¶
- architektura jest wciąż zbyt skomplikowana - zunifikować bloki
- wersja 4 wprowadza 3 typy bloków A, B, i C
- bloki są zaimportowane z poprzednich wersji
- zmodyfikować początkowy korzeń drzewa (stem)
- początkowe przetwarzanie w korzeniu okazywało się bardzo istotne we wszystkich wersjach
- dodatkowo wprowadzone bloki redukcji
- pozwalają na zmianę wymiarów explicite
- pozwalają na zmianę wymiarów explicite
Liczba uczonych parametrów¶
- Inception ma znacznie mniejszą liczbę parametrów do uczenia
Porównanie wyników¶
- dla porównanie musimy wziąć pod uwagę liczbę parametrów, jak długo model trzeba liczyć, oraz skuteczność
- Top-1 to frakcja przykładów, które model poprawnie sklasyfikował
- Top-5 to frakcja przykładów, gdy prawdziwa klasa była wskazana jako jedna z pierwszych pięciu najbardziej prawdopodobnych